package org.red_cross_service.utils;

import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.metadata.TableInfo;
import com.baomidou.mybatisplus.core.metadata.TableInfoHelper;
import org.red_cross_service.common.anno.Query;

import java.lang.reflect.Field;
import java.util.Collection;

public class QueryWrapperUtils {

    /**
     * 动态拼接查询条件
     *
     * @param entity 实体对象
     * @return 构建好的 QueryWrapper
     */
    public static <T> QueryWrapper<T> buildQuery(T entity) {
        QueryWrapper<T> queryWrapper = new QueryWrapper<>();

        if (entity == null) {
            return queryWrapper;
        }

        // 获取实体类的 Class 对象
        Class<?> clazz = entity.getClass();

        // 获取实体类对应的表信息
        TableInfo tableInfo = TableInfoHelper.getTableInfo(clazz);
        if (tableInfo == null) {
            throw new RuntimeException("Failed to get table info for class: " + clazz.getName());
        }

        // 遍历实体类的字段
        for (Field field : clazz.getDeclaredFields()) {

            // 跳过标注了 @TableField(exist = false) 的字段
            if (field.isAnnotationPresent(TableField.class)) {
                TableField tableField = field.getAnnotation(TableField.class);
                if (!tableField.exist()) {
                    continue;
                }
            }

            field.setAccessible(true); // 设置字段可访问
            try {
                Object value = field.get(entity); // 获取字段值
                if (value != null) {
                    String fieldName = field.getName();

                    // 获取数据库列名
                    String columnName = tableInfo.getFieldList().stream()
                            .filter(tableFieldInfo -> tableFieldInfo.getProperty().equals(fieldName))
                            .findFirst()
                            .map(tableFieldInfo -> tableFieldInfo.getColumn())
                            .orElse(fieldName); // 如果没有找到映射关系，则使用字段名

                    // 检查是否标注了 @Query 注解
                    if (field.isAnnotationPresent(Query.class)) {
                        Query queryAnnotation = field.getAnnotation(Query.class);
                        Query.QueryType queryType = queryAnnotation.type();

                        // 根据查询类型动态拼接条件
                        switch (queryType) {
                            case LIKE:
                                queryWrapper.like(columnName, value); // 模糊查询
                                break;
                            case IN:
                                if (value instanceof Collection) {
                                    queryWrapper.in(columnName, (Collection<?>) value); // IN 查询
                                }
                                break;
                            case BETWEEN:
                                if (value instanceof Object[] && ((Object[]) value).length == 2) {
                                    Object[] range = (Object[]) value;
                                    queryWrapper.between(columnName, range[0], range[1]); // 范围查询
                                }
                                break;
                            case EQ:
                            default:
                                queryWrapper.eq(columnName, value); // 默认 = 查询
                                break;
                        }
                    } else {
                        // 没有注解，默认使用 = 查询
                        queryWrapper.eq(columnName, value);
                    }
                }
            } catch (IllegalAccessException e) {
                throw new RuntimeException("Failed to build query conditions", e);
            }
        }

        return queryWrapper;
    }
}